
package com.gongyibao.gbase.utils;

import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringEscapeUtils;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 二次封装的常用字符串转换
 * 
 * @ClassName StringUtils
 * @Description 二次封装的常用字符串转换
 * @author Kunpeng
 * @date 2018年4月11日 下午8:19:29
 * 
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {
    private static final String CHARSET_NAME = "UTF-8";
    private static final Pattern PATTERN_ISMOBILE = Pattern.compile("^1\\d{10}$");

    /**
     * 判断是否为手机号 格式1开头，11位数就满足了
     * 
     * @param mobile
     *            手机号码字符串
     * @return
     */
    public static boolean isMobileNO(String mobile) {
        if (!isBlank(mobile)) {
            Matcher m = PATTERN_ISMOBILE.matcher(mobile);
            return m.matches();
        } else {
            return false;
        }
    }

    /**
     * 检查用户邮箱格式
     * @param email
     * @return
     */
    public static Boolean checkEmail(String email) {
        boolean flag = false;
        try {
            String check = "^([a-z0-9A-Z]+[-|_|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
            Pattern regex = Pattern.compile(check);
            Matcher matcher = regex.matcher(email);
            flag = matcher.matches();
        } catch (Exception e) {
            flag = false;
        }
        return flag;
    }

    /**
     * 生成业务流水号 系统标识（sysFlg.length位）+时间（14位，年月日时分秒毫秒4）+系统流水（randomCount位）
     * 
     * @param sysFlg
     *            系统标识
     * @param randomCount
     *            随机数位数
     * @return
     */
    public static synchronized String createSerial(String sysFlg, int randomCount) {
        // safeSleep(1);
        SimpleDateFormat sdft = new SimpleDateFormat("yyyyMMddHHmmssSSSS");
        Date nowdate = new Date();
        String str = sdft.format(nowdate);
        return sysFlg + str + RandomStringUtils.randomNumeric(randomCount);
    }

    /**
     * 
     * 时间转字符串 yyyy-MM-dd HH:mm:ss
     * 
     * @Title getDateString
     * @Description 时间转字符串 yyyy-MM-dd HH:mm:ss
     * @return String 返回类型
     */
    public static String getDateTimeString() {
        return getDateTimeString(new Date());
    }

    /**
     * 
     * 时间转字符串 yyyy-MM-dd HH:mm:ss
     * 
     * @Title getDateString
     * @Description 时间转字符串 yyyy-MM-dd HH:mm:ss
     * @param date
     * @return String 返回类型
     */
    public static String getDateTimeString(Date date) {
        return getDateTimeString(date, "yyyy-MM-dd HH:mm:ss");
    }

    public static String getDateString() {
        return getDateString(new Date());
    }

    public static String getDateString(Date date) {
        return getDateTimeString(date, "yyyy-MM-dd");
    }

    public static String getDateTimeString(Date date, String format) {
        SimpleDateFormat sdft = new SimpleDateFormat(format);
        return sdft.format(date);
    }

    /**
     *  
     * 当前时间转字符串
     * <pre>
     * type :
     *    a : yyyy-MM-dd HH:mm:ss (default)
     *    b : yyyyMMdd
     *    c : yyyyMMddHHmmss
     *    d : yyyy-MM-dd
     *    e : yyyyMMddHHmmssSSS
     *    f : yyyy-MM-dd HH:mm:ss.SSS
     * </pre>
     * @Title getNowString 
     * @Description (这里用一句话描述这个方法的作用) 
     * @param type
     * @return String 返回类型
     */
    public static String getNowString(String type) {
        String value = "";
        Date date = new Date();
        if (null == type) {
            type = "";
        }
        type = type.toLowerCase();
        switch (type) {
        case "b":
            value = getDateTimeString(date, "yyyyMMdd");
            break;
        case "c":
            value = getDateTimeString(date, "yyyyMMddHHmmss");
            break;
        case "d":
            value = getDateTimeString(date, "yyyy-MM-dd");
            break;
        case "e":
            value = getDateTimeString(date, "yyyyMMddHHmmssSSS");
            break;
        case "f":
            value = getDateTimeString(date, "yyyy-MM-dd HH:mm:ss.SSS");
            break;
        default:
            value = getDateTimeString(date, "yyyy-MM-dd HH:mm:ss");
            break;
        }
        return value;
    }

    /**
     * 转换为Boolean类型 'true', 'on', 'y', 't', 'yes' or '1' (case insensitive) will
     * return true. Otherwise, false is returned.
     */
    public static Boolean toBoolean(final Object val) {
        if (val == null) {
            return false;
        }
        return BooleanUtils.toBoolean(trim(val.toString())) || "1".equals(val.toString());
    }

    /**
     * 转为 BigDecimal
     * 
     * @Title toDecimal
     * @Description 转为 BigDecimal
     * @param val
     * @return BigDecimal 返回类型
     */
    public static BigDecimal toDecimal(final Object val) {
        if (val == null) {
            return new BigDecimal(0);
        }
        BigDecimal value = new BigDecimal(0);
        try {
            value = new BigDecimal(val.toString());
        } catch (Exception e) {
        }
        return value;
    }

    /**
     * 保留两位小数
     * @param d
     * @return
     */
    public static Double keepTwoPosition(Double d){
        if(d == null){
            return new Double(0);
        }
        BigDecimal b = new BigDecimal(d);
        return b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 转换为Double类型
     * 
     * @Title toDouble
     * @Description 转换为Double类型
     * @param val
     * @return Double 返回类型
     */
    public static Double toDouble(final Object val) {
        if (val == null) {
            return 0D;
        }
        try {
            return Double.valueOf(trim(val.toString()));
        } catch (Exception e) {
            return 0D;
        }
    }

    /**
     * 
     * 转换为Float类型
     * 
     * @Title toFloat
     * @Description 转换为Float类型
     * @param val
     * @return Float 返回类型
     */
    public static Float toFloat(Object val) {
        return toDouble(val).floatValue();
    }

    /**
     * 
     * 转换为Long类型
     * 
     * @Title toLong
     * @Description 转换为Long类型
     * @param val
     * @return Long 返回类型
     */
    public static Long toLong(Object val) {
        return toDouble(val).longValue();
    }

    /**
     * 
     * 转换为Integer类型
     * 
     * @Title toInteger
     * @Description 转换为Integer类型
     * @param val
     * @return Integer 返回类型
     */
    public static Integer toInteger(Object val) {
        return toLong(val).intValue();
    }

    /**
     * 
     * String转换为byte[]
     * 
     * @Title getBytes
     * @Description String转换为byte[]
     * @param str
     * @return byte[] 返回类型
     */
    public static byte[] getBytes(String str) {
        if (str != null) {
            try {
                return str.getBytes(CHARSET_NAME);
            } catch (UnsupportedEncodingException e) {
                return null;
            }
        } else {
            return null;
        }
    }

    /**
     * 
     * byte[]转换为String
     * 
     * @Title toString
     * @Description byte[]转换为String
     * @param bytes
     * @return String 返回类型
     */
    public static String toString(byte[] bytes) {
        try {
            return new String(bytes, CHARSET_NAME);
        } catch (UnsupportedEncodingException e) {
            return EMPTY;
        }
    }

    /**
     * 
     * 字符串转 List<String>
     * 
     * @Title toList
     * @Description 字符串转 List<String>
     * @param str
     * @param separatorChars
     * @return List<String> 返回类型
     */
    public static List<String> toList(String str, String separatorChars) {
        List<String> list = new ArrayList<String>();
        for (String it : StringUtils.split(str, separatorChars)) {
            if (!list.contains(it)) {
                list.add(it);
            }
        }
        return list;
    }

    /**
     * 
     * 字符串转 List<Integer>
     * 
     * @Title toIntList
     * @Description 字符串转 List<Integer>
     * @param str
     * @param separatorChars
     * @return List<String> 返回类型
     */
    public static List<Integer> toIntList(String str, String separatorChars) {
        List<Integer> list = new ArrayList<Integer>();
        for (String it : StringUtils.split(str, separatorChars)) {
            int val = toInteger(it);
            if (!list.contains(val)) {
                list.add(val);
            }
        }
        return list;
    }

    /**
     * 
     * 字符串转 List<Double>
     * 
     * @Title toDoubleList
     * @Description 字符串转 List<Double>
     * @param str
     * @param separatorChars
     * @return List<String> 返回类型
     */
    public static List<Double> toDoubleList(String str, String separatorChars) {
        List<Double> list = new ArrayList<Double>();
        for (String it : StringUtils.split(str, separatorChars)) {
            Double val = toDouble(it);
            if (!list.contains(val)) {
                list.add(val);
            }
        }
        return list;
    }

    /**
     * 
     * 字符串转 List<BigDecimal>
     * 
     * @Title toDecimalList
     * @Description 字符串转 List<BigDecimal>
     * @param str
     * @param separatorChars
     * @return List<String> 返回类型
     */
    public static List<BigDecimal> toDecimalList(String str, String separatorChars) {
        List<BigDecimal> list = new ArrayList<BigDecimal>();
        for (String it : StringUtils.split(str, separatorChars)) {
            BigDecimal val = toDecimal(it);
            if (!list.contains(val)) {
                list.add(val);
            }
        }
        return list;
    }

    /**
     * object 是否为空
     * @param o
     * @return
     */
    public static boolean isBlank(Object o){
        if (o == null) {
            return true;
        }
        return isBlank(o.toString());
    }
    /**
     *@description：截取字符串的长度
     *@params：
     *@return：
     */
    public static String abbr(String str,int length){
        if(str == null){
            return "";
        }

        StringBuffer sb = new StringBuffer();
        int currentLenth =0;
        for(char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()){
            currentLenth +=String.valueOf(c).getBytes().length;
            if(currentLenth<=length-3){
                sb.append(c);
            }else{
                sb.append("...");
            }
        }
        return sb.toString();
    }
    /**
     * 替换掉HTML标签方法
     */
    public static String replaceHtml(String html) {
        if (isBlank(html)){
            return "";
        }
        String regEx = "<.+?>";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(html);
        String s = m.replaceAll("");
        return s;
    }
    /**
     * 校验字符串是否为数字
     */
    public static Boolean isInteger(String str){
        if(StringUtils.isBlank(str)){
            return false;
        }
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }

    /**
     * 数字前补0
     */
    public static String repairZero(String str,int num){
        int length = str.length();
        if(length<num){
            for (int i=length;length<=num;length++){
                StringBuffer sb = new StringBuffer();
                sb.append("0").append(str);
                str = sb.toString();
                length =str.length();
            }
        }
        return str;
    }

    /**
     * 字符串转List<String></>
     * @param str
     * @return
     */
    public static List<String> stringToListStr(String str){
        String[] split = str.split(",");
        return   Arrays.asList(split);
    }

}
